/*
    * Copyright (C) 2009 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.reflect;
  
  import static com.google.common.base.Preconditions.checkArgument;
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  
  import com.google.common.annotations.Beta;
  import com.google.common.base.Joiner;
  import com.google.common.base.Objects;
  import com.google.common.collect.ImmutableMap;
  import com.google.common.collect.Maps;
  
  import java.lang.reflect.GenericArrayType;
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  import java.lang.reflect.TypeVariable;
  import java.lang.reflect.WildcardType;
  import java.util.Arrays;
  import java.util.Map;
  import java.util.concurrent.atomic.AtomicInteger;
  
  import javax.annotation.Nullable;
  
  /**
   * An object of this class encapsulates type mappings from type variables. Mappings are established
   * with {@link #where} and types are resolved using {@link #resolveType}.
   *
   * <p>Note that usually type mappings are already implied by the static type hierarchy (for example,
   * the {@code E} type variable declared by class {@code List} naturally maps to {@code String} in
   * the context of {@code class MyStringList implements List<String>}. In such case, prefer to use
   * {@link TypeToken#resolveType} since it's simpler and more type safe. This class should only be
   * used when the type mapping isn't implied by the static type hierarchy, but provided through other
   * means such as an annotation or external configuration file.
   *
   * @author Ben Yu
   * @since 15.0
   */
  @Beta
  public final class TypeResolver {
  
    private final TypeTable typeTable;
  
    public TypeResolver() {
      this.typeTable = new TypeTable();
    }
  
    private TypeResolver(TypeTable typeTable) {
      this.typeTable = typeTable;
    }
  
    static TypeResolver accordingTo(Type type) {
      return new TypeResolver().where(TypeMappingIntrospector.getTypeMappings(type));
    }
  
    /**
     * Returns a new {@code TypeResolver} with type variables in {@code formal} mapping to types in
     * {@code actual}.
     *
     * <p>For example, if {@code formal} is a {@code TypeVariable T}, and {@code actual} is {@code
     * String.class}, then {@code new TypeResolver().where(formal, actual)} will {@linkplain
     * #resolveType resolve} {@code ParameterizedType List<T>} to {@code List<String>}, and resolve
     * {@code Map<T, Something>} to {@code Map<String, Something>} etc. Similarly, {@code formal} and
     * {@code actual} can be {@code Map<K, V>} and {@code Map<String, Integer>} respectively, or they
     * can be {@code E[]} and {@code String[]} respectively, or even any arbitrary combination
     * thereof.
     *
     * @param formal The type whose type variables or itself is mapped to other type(s). It's almost
     *        always a bug if {@code formal} isn't a type variable and contains no type variable. Make
     *        sure you are passing the two parameters in the right order.
     * @param actual The type that the formal type variable(s) are mapped to. It can be or contain yet
     *        other type variables, in which case these type variables will be further resolved if
     *        corresponding mappings exist in the current {@code TypeResolver} instance.
     */
    public TypeResolver where(Type formal, Type actual) {
      Map<TypeVariableKey, Type> mappings = Maps.newHashMap();
      populateTypeMappings(mappings, checkNotNull(formal), checkNotNull(actual));
      return where(mappings);
    }
  
    /** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
    TypeResolver where(Map<TypeVariableKey, ? extends Type> mappings) {
      return new TypeResolver(typeTable.where(mappings));
    }
 
   private static void populateTypeMappings(
       final Map<TypeVariableKey, Type> mappings, Type from, final Type to) {
     if (from.equals(to)) {
       return;
     }
     new TypeVisitor() {
       @Override void visitTypeVariable(TypeVariable<?> typeVariable) {
         mappings.put(new TypeVariableKey(typeVariable), to);
       }
       @Override void visitWildcardType(WildcardType fromWildcardType) {
         WildcardType toWildcardType = expectArgument(WildcardType.class, to);
         Type[] fromUpperBounds = fromWildcardType.getUpperBounds();
         Type[] toUpperBounds = toWildcardType.getUpperBounds();
         Type[] fromLowerBounds = fromWildcardType.getLowerBounds();
         Type[] toLowerBounds = toWildcardType.getLowerBounds();
         checkArgument(
             fromUpperBounds.length == toUpperBounds.length
                 && fromLowerBounds.length == toLowerBounds.length,
             "Incompatible type: %s vs. %s", fromWildcardType, to);
         for (int i = 0; i < fromUpperBounds.length; i++) {
           populateTypeMappings(mappings, fromUpperBounds[i], toUpperBounds[i]);
         }
         for (int i = 0; i < fromLowerBounds.length; i++) {
           populateTypeMappings(mappings, fromLowerBounds[i], toLowerBounds[i]);
         }
       }
       @Override void visitParameterizedType(ParameterizedType fromParameterizedType) {
         ParameterizedType toParameterizedType = expectArgument(ParameterizedType.class, to);
         checkArgument(fromParameterizedType.getRawType().equals(toParameterizedType.getRawType()),
             "Inconsistent raw type: %s vs. %s", fromParameterizedType, to);
         Type[] fromArgs = fromParameterizedType.getActualTypeArguments();
         Type[] toArgs = toParameterizedType.getActualTypeArguments();
         checkArgument(fromArgs.length == toArgs.length,
             "%s not compatible with %s", fromParameterizedType, toParameterizedType);
         for (int i = 0; i < fromArgs.length; i++) {
           populateTypeMappings(mappings, fromArgs[i], toArgs[i]);
         }
       }
       @Override void visitGenericArrayType(GenericArrayType fromArrayType) {
         Type componentType = Types.getComponentType(to);
         checkArgument(componentType != null, "%s is not an array type.", to);
         populateTypeMappings(mappings, fromArrayType.getGenericComponentType(), componentType);
       }
       @Override void visitClass(Class<?> fromClass) {
         // Can't map from a raw class to anything other than itself.
         // You can't say "assuming String is Integer".
         // And we don't support "assuming String is T"; user has to say "assuming T is String". 
         throw new IllegalArgumentException("No type mapping from " + fromClass);
       }
     }.visit(from);
   }
 
   /**
    * Resolves all type variables in {@code type} and all downstream types and
    * returns a corresponding type with type variables resolved.
    */
   public Type resolveType(Type type) {
     checkNotNull(type);
     if (type instanceof TypeVariable) {
       return typeTable.resolve((TypeVariable<?>) type);
     } else if (type instanceof ParameterizedType) {
       return resolveParameterizedType((ParameterizedType) type);
     } else if (type instanceof GenericArrayType) {
       return resolveGenericArrayType((GenericArrayType) type);
     } else if (type instanceof WildcardType) {
       return resolveWildcardType((WildcardType) type);
     } else {
       // if Class<?>, no resolution needed, we are done.
       return type;
     }
   }
 
   private Type[] resolveTypes(Type[] types) {
     Type[] result = new Type[types.length];
     for (int i = 0; i < types.length; i++) {
       result[i] = resolveType(types[i]);
     }
     return result;
   }
 
   private WildcardType resolveWildcardType(WildcardType type) {
     Type[] lowerBounds = type.getLowerBounds();
     Type[] upperBounds = type.getUpperBounds();
     return new Types.WildcardTypeImpl(
         resolveTypes(lowerBounds), resolveTypes(upperBounds));
   }
 
   private Type resolveGenericArrayType(GenericArrayType type) {
     Type componentType = type.getGenericComponentType();
     Type resolvedComponentType = resolveType(componentType);
     return Types.newArrayType(resolvedComponentType);
   }
 
   private ParameterizedType resolveParameterizedType(ParameterizedType type) {
     Type owner = type.getOwnerType();
     Type resolvedOwner = (owner == null) ? null : resolveType(owner);
     Type resolvedRawType = resolveType(type.getRawType());
 
     Type[] args = type.getActualTypeArguments();
     Type[] resolvedArgs = resolveTypes(args);
     return Types.newParameterizedTypeWithOwner(
         resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs);
   }
 
   private static <T> T expectArgument(Class<T> type, Object arg) {
     try {
       return type.cast(arg);
     } catch (ClassCastException e) {
       throw new IllegalArgumentException(arg + " is not a " + type.getSimpleName());
     }
   }
 
   /** A TypeTable maintains mapping from {@link TypeVariable} to types. */
   private static class TypeTable {
     private final ImmutableMap<TypeVariableKey, Type> map;
   
     TypeTable() {
       this.map = ImmutableMap.of();
     }
     
     private TypeTable(ImmutableMap<TypeVariableKey, Type> map) {
       this.map = map;
     }
 
     /** Returns a new {@code TypeResolver} with {@code variable} mapping to {@code type}. */
     final TypeTable where(Map<TypeVariableKey, ? extends Type> mappings) {
       ImmutableMap.Builder<TypeVariableKey, Type> builder = ImmutableMap.builder();
       builder.putAll(map);
       for (Map.Entry<TypeVariableKey, ? extends Type> mapping : mappings.entrySet()) {
         TypeVariableKey variable = mapping.getKey();
         Type type = mapping.getValue();
         checkArgument(!variable.equalsType(type), "Type variable %s bound to itself", variable);
         builder.put(variable, type);
       }
       return new TypeTable(builder.build());
     }
 
     final Type resolve(final TypeVariable<?> var) {
       final TypeTable unguarded = this;
       TypeTable guarded = new TypeTable() {
         @Override public Type resolveInternal(
             TypeVariable<?> intermediateVar, TypeTable forDependent) {
           if (intermediateVar.getGenericDeclaration().equals(var.getGenericDeclaration())) {
             return intermediateVar;
           }
           return unguarded.resolveInternal(intermediateVar, forDependent);
         }
       };
       return resolveInternal(var, guarded);
     }
 
     /**
      * Resolves {@code var} using the encapsulated type mapping. If it maps to yet another
      * non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
      * doesn't try to resolve any type variable on generic declarations that are already being
      * resolved.
      *
      * <p>Should only be called and overridden by {@link #resolve(TypeVariable)}.
      */
     Type resolveInternal(TypeVariable<?> var, TypeTable forDependants) {
       Type type = map.get(new TypeVariableKey(var));
       if (type == null) {
         Type[] bounds = var.getBounds();
         if (bounds.length == 0) {
           return var;
         }
         Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
         /*
          * We'd like to simply create our own TypeVariable with the newly resolved bounds. There's
          * just one problem: Starting with JDK 7u51, the JDK TypeVariable's equals() method doesn't
          * recognize instances of our TypeVariable implementation. This is a problem because users
          * compare TypeVariables from the JDK against TypeVariables returned by TypeResolver. To
          * work with all JDK versions, TypeResolver must return the appropriate TypeVariable
          * implementation in each of the three possible cases:
          *
          * 1. Prior to JDK 7u51, the JDK TypeVariable implementation interoperates with ours.
          * Therefore, we can always create our own TypeVariable.
          *
          * 2. Starting with JDK 7u51, the JDK TypeVariable implementations does not interoperate
          * with ours. Therefore, we have to be careful about whether we create our own TypeVariable:
          *
          * 2a. If the resolved types are identical to the original types, then we can return the
          * original, identical JDK TypeVariable. By doing so, we sidestep the problem entirely.
          *
          * 2b. If the resolved types are different from the original types, things are trickier. The
          * only way to get a TypeVariable instance for the resolved types is to create our own. The
          * created TypeVariable will not interoperate with any JDK TypeVariable. But this is OK: We
          * don't _want_ our new TypeVariable to be equal to the JDK TypeVariable because it has
          * _different bounds_ than the JDK TypeVariable. And it wouldn't make sense for our new
          * TypeVariable to be equal to any _other_ JDK TypeVariable, either, because any other JDK
          * TypeVariable must have a different declaration or name. The only TypeVariable that our
          * new TypeVariable _will_ be equal to is an equivalent TypeVariable that was also created
          * by us. And that equality is guaranteed to hold because it doesn't involve the JDK
          * TypeVariable implementation at all.
          */
         if (Types.NativeTypeVariableEquals.NATIVE_TYPE_VARIABLE_ONLY
             && Arrays.equals(bounds, resolvedBounds)) {
           return var;
         }
         return Types.newArtificialTypeVariable(
             var.getGenericDeclaration(), var.getName(), resolvedBounds);
       }
       // in case the type is yet another type variable.
       return new TypeResolver(forDependants).resolveType(type);
     }
   }
 
   private static final class TypeMappingIntrospector extends TypeVisitor {
 
     private static final WildcardCapturer wildcardCapturer = new WildcardCapturer();
 
     private final Map<TypeVariableKey, Type> mappings = Maps.newHashMap();
 
     /**
      * Returns type mappings using type parameters and type arguments found in
      * the generic superclass and the super interfaces of {@code contextClass}.
      */
     static ImmutableMap<TypeVariableKey, Type> getTypeMappings(
         Type contextType) {
       TypeMappingIntrospector introspector = new TypeMappingIntrospector();
       introspector.visit(wildcardCapturer.capture(contextType));
       return ImmutableMap.copyOf(introspector.mappings);
     }
 
     @Override void visitClass(Class<?> clazz) {
       visit(clazz.getGenericSuperclass());
       visit(clazz.getGenericInterfaces());
     }
 
     @Override void visitParameterizedType(ParameterizedType parameterizedType) {
       Class<?> rawClass = (Class<?>) parameterizedType.getRawType();
       TypeVariable<?>[] vars = rawClass.getTypeParameters();
       Type[] typeArgs = parameterizedType.getActualTypeArguments();
       checkState(vars.length == typeArgs.length);
       for (int i = 0; i < vars.length; i++) {
         map(new TypeVariableKey(vars[i]), typeArgs[i]);
       }
       visit(rawClass);
       visit(parameterizedType.getOwnerType());
     }
 
     @Override void visitTypeVariable(TypeVariable<?> t) {
       visit(t.getBounds());
     }
 
     @Override void visitWildcardType(WildcardType t) {
       visit(t.getUpperBounds());
     }
 
     private void map(final TypeVariableKey var, final Type arg) {
       if (mappings.containsKey(var)) {
         // Mapping already established
         // This is possible when following both superClass -> enclosingClass
         // and enclosingclass -> superClass paths.
         // Since we follow the path of superclass first, enclosing second,
         // superclass mapping should take precedence.
         return;
       }
       // First, check whether var -> arg forms a cycle
       for (Type t = arg; t != null; t = mappings.get(TypeVariableKey.forLookup(t))) {
         if (var.equalsType(t)) {
           // cycle detected, remove the entire cycle from the mapping so that
           // each type variable resolves deterministically to itself.
           // Otherwise, a F -> T cycle will end up resolving both F and T
           // nondeterministically to either F or T.
           for (Type x = arg; x != null; x = mappings.remove(TypeVariableKey.forLookup(x))) {}
           return;
         }
       }
       mappings.put(var, arg);
     }
   }
 
   // This is needed when resolving types against a context with wildcards
   // For example:
   // class Holder<T> {
   //   void set(T data) {...}
   // }
   // Holder<List<?>> should *not* resolve the set() method to set(List<?> data).
   // Instead, it should create a capture of the wildcard so that set() rejects any List<T>.
   private static final class WildcardCapturer {
 
     private final AtomicInteger id = new AtomicInteger();
 
     Type capture(Type type) {
       checkNotNull(type);
       if (type instanceof Class) {
         return type;
       }
       if (type instanceof TypeVariable) {
         return type;
       }
       if (type instanceof GenericArrayType) {
         GenericArrayType arrayType = (GenericArrayType) type;
         return Types.newArrayType(capture(arrayType.getGenericComponentType()));
       }
       if (type instanceof ParameterizedType) {
         ParameterizedType parameterizedType = (ParameterizedType) type;
         return Types.newParameterizedTypeWithOwner(
             captureNullable(parameterizedType.getOwnerType()),
             (Class<?>) parameterizedType.getRawType(),
             capture(parameterizedType.getActualTypeArguments()));
       }
       if (type instanceof WildcardType) {
         WildcardType wildcardType = (WildcardType) type;
         Type[] lowerBounds = wildcardType.getLowerBounds();
         if (lowerBounds.length == 0) { // ? extends something changes to capture-of
           Type[] upperBounds = wildcardType.getUpperBounds();
           String name = "capture#" + id.incrementAndGet() + "-of ? extends "
               + Joiner.on('&').join(upperBounds);
           return Types.newArtificialTypeVariable(
               WildcardCapturer.class, name, wildcardType.getUpperBounds());
         } else {
           // TODO(benyu): handle ? super T somehow.
           return type;
         }
       }
       throw new AssertionError("must have been one of the known types");
     }
 
     private Type captureNullable(@Nullable Type type) {
       if (type == null) {
         return null;
       }
       return capture(type);
     }
 
     private Type[] capture(Type[] types) {
       Type[] result = new Type[types.length];
       for (int i = 0; i < types.length; i++) {
         result[i] = capture(types[i]);
       }
       return result;
     }
   }
 
   /**
    * Wraps around {@code TypeVariable<?>} to ensure that any two type variables are equal as long as
    * they are declared by the same {@link java.lang.reflect.GenericDeclaration} and have the same
    * name, even if their bounds differ.
    *
    * <p>While resolving a type variable from a {var -> type} map, we don't care whether the
    * type variable's bound has been partially resolved. As long as the type variable "identity"
    * matches.
    *
    * <p>On the other hand, if for example we are resolving List<A extends B> to
    * List<A extends String>, we need to compare that <A extends B> is unequal to
    * <A extends String> in order to decide to use the transformed type instead of the original
    * type.
    */
   static final class TypeVariableKey {
     private final TypeVariable<?> var;
 
     TypeVariableKey(TypeVariable<?> var) {
       this.var = checkNotNull(var);
     }
 
     @Override public int hashCode() {
       return Objects.hashCode(var.getGenericDeclaration(), var.getName());
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof TypeVariableKey) {
         TypeVariableKey that = (TypeVariableKey) obj;
         return equalsTypeVariable(that.var);
       } else {
         return false;
       }
     }
 
     @Override public String toString() {
       return var.toString();
     }
 
     /** Wraps {@code t} in a {@code TypeVariableKey} if it's a type variable. */
     static Object forLookup(Type t) {
       if (t instanceof TypeVariable) {
         return new TypeVariableKey((TypeVariable<?>) t);
       } else {
         return null;
       }
     }
 
     /**
      * Returns true if {@code type} is a {@code TypeVariable} with the same name and declared by
      * the same {@code GenericDeclaration}.
      */
     boolean equalsType(Type type) {
       if (type instanceof TypeVariable) {
         return equalsTypeVariable((TypeVariable<?>) type);
       } else {
         return false;
       }
     }
 
     private boolean equalsTypeVariable(TypeVariable<?> that) {
       return var.getGenericDeclaration().equals(that.getGenericDeclaration())
           && var.getName().equals(that.getName());
     }
   }
 }